React Server Action 验证：表单输入处理与安全的综合指南

            // app/actions.js
'use server';

export async function createUser(formData) {
  const name = formData.get('name');
  const email = formData.get('email');

  // ... logic to save user to the database
  console.log('Creating user:', { name, email });
}

// app/page.js
import { createUser } from './actions';

export default function UserForm() {
  return (
    

      
      
      Create User
    
  );
}
            

              
                Copy
              
            
          

            // app/actions.js
'use server';

import { redirect } from 'next/navigation';

export async function createInvoice(formData) {
  const customerName = formData.get('customerName');
  const amount = formData.get('amount');

  if (!customerName || customerName.trim() === '') {
    return { success: false, message: 'Customer name is required.' };
  }

  if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
    return { success: false, message: 'Please enter a valid amount greater than zero.' };
  }

  // ... logic to create the invoice in the database
  console.log('Invoice created for', customerName, 'with amount', amount);
  
  redirect('/dashboard/invoices');
}
            

              
                Copy
              
            
          

            // app/actions.js
'use server';

import { revalidatePath } from 'next/cache';
import { redirect } from 'next/navigation';

// Define the initial state shape
const initialState = {
  message: null,
  errors: {},
};

export async function createInvoice(prevState, formData) {
  const customerName = formData.get('customerName');
  const amount = formData.get('amount');
  const status = formData.get('status');

  const errors = {};
  if (!customerName || customerName.trim().length < 2) {
    errors.customerName = 'Customer name must be at least 2 characters.';
  }
  if (!amount || isNaN(Number(amount)) || Number(amount) <= 0) {
    errors.amount = 'Please enter a valid amount.';
  }
  if (status !== 'pending' && status !== 'paid') {
    errors.status = 'Please select a valid status.';
  }

  if (Object.keys(errors).length > 0) {
    return {
      message: 'Failed to create invoice. Please check the fields.',
      errors,
    };
  }

  try {
    // ... logic to save to database
    console.log('Invoice created successfully!');
  } catch (e) {
    return {
      message: 'Database Error: Failed to create invoice.',
      errors: {},
    };
  }

  // Revalidate the cache for the invoices page and redirect
  revalidatePath('/dashboard/invoices');
  redirect('/dashboard/invoices');
}

            

              
                Copy
              
            
          

            // app/ui/invoices/create-form.js
'use client';

import { useFormState } from 'react-dom';
import { createInvoice } from '@/app/actions';

const initialState = {
  message: null,
  errors: {},
};

export function CreateInvoiceForm() {
  const [state, dispatch] = useFormState(createInvoice, initialState);

  return (
    

      

        Customer Name
        
        {state.errors?.customerName && 
          
{state.errors.customerName}
}
      
      
      

        Amount
        
        {state.errors?.amount && 
          
{state.errors.amount}
}
      

      {/* ... other fields ... */}

      {state.message && 
{state.message}
}
      
      Create Invoice
    
  );
}
            

              
                Copy
              
            
          

            // app/lib/schemas.js
import { z } from 'zod';

export const InvoiceSchema = z.object({
  id: z.string(), // We'll have this for updates, but not creation
  customerId: z.string({ invalid_type_error: 'Please select a customer.' }),
  amount: z.coerce
    .number()
    .gt(0, { message: 'Please enter an amount greater than $0.' }),
  status: z.enum(['pending', 'paid'], {
    invalid_type_error: 'Please select an invoice status.',
  }),
  date: z.string(),
});

export const CreateInvoice = InvoiceSchema.omit({ id: true, date: true });
            

              
                Copy
              
            
          

            // app/actions.js
'use server';

import { z } from 'zod';
import { CreateInvoice } from '@/app/lib/schemas';

export async function createInvoiceWithZod(prevState, formData) {
  // 1. Validate form fields using Zod
  const validatedFields = CreateInvoice.safeParse({
    customerId: formData.get('customerId'),
    amount: formData.get('amount'),
    status: formData.get('status'),
  });

  // 2. If validation fails, return errors early.
  if (!validatedFields.success) {
    return {
      errors: validatedFields.error.flatten().fieldErrors,
      message: 'Missing Fields. Failed to Create Invoice.',
    };
  }

  // 3. Prepare data for insertion into the database
  const { customerId, amount, status } = validatedFields.data;
  const amountInCents = amount * 100;
  const date = new Date().toISOString().split('T')[0];

  // 4. Insert data into the database
  try {
    // await sql`...` your database query here
    console.log('Successfully created invoice with validated data.');
  } catch (error) {
    return {
      message: 'Database Error: Failed to Create Invoice.',
    };
  }

  // 5. Revalidate and redirect
  revalidatePath('/dashboard/invoices');
  redirect('/dashboard/invoices');
}
            

              
                Copy
              
            
          

            // app/actions.js
'use server';

import { auth } from '@/auth'; // Assuming you use NextAuth.js or similar
import { sql } from '@vercel/postgres';

export async function deleteInvoice(id) {
  const session = await auth();
  if (!session?.user) {
    // Or throw an error
    return { message: 'Authentication required.' };
  }

  // Authorization check: Does this user have permission to delete?
  // This could involve checking roles or ownership.
  const userRole = session.user.role;
  if (userRole !== 'admin') {
    return { message: 'Unauthorized action.' };
  }

  try {
    await sql`DELETE FROM invoices WHERE id = ${id}`;
    revalidatePath('/dashboard/invoices');
    return { message: 'Deleted Invoice.' };
  } catch (error) {
    return { message: 'Database Error: Failed to Delete Invoice.' };
  }
}
            

              
                Copy
              
            
          

            import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

// Create a new ratelimiter, allowing 5 requests per 10 seconds
const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(5, '10 s'),
});

export async function sensitiveAction(formData) {
  const ip = headers().get('x-forwarded-for'); // Or get user ID from session
  const { success } = await ratelimit.limit(ip);

  if (!success) {
    return { message: 'Too many requests. Please try again later.' };
  }

  // ... rest of the action logic
}
            

              
                Copy
              
            
          

            // In the action
if (!validatedFields.success) {
  // ...
  return { errors: { customerId: ['error.customer.required'] } };
}

// In the client component, using a library like 'react-i18next'
import { useTranslation } from 'react-i18next';

function MyForm() {
  const { t } = useTranslation();
  const [state, dispatch] = useFormState(...);

  // ...
  {state.errors?.customerId && 
    
{t(state.errors.customerId[0])}
}
}
            

              
                Copy
              
            
          

            

  Customer Name
  
  

    {state.errors?.customerName &&
      state.errors.customerName.map((error) => (
        
{error}
      ))}
  

            

              
                Copy